/*
** Lua binding: WndBasePkg
** Generated automatically by tolua++-1.0.92 on 03/17/12 11:32:48.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
TOLUA_API int  tolua_WndBasePkg_open (lua_State* tolua_S);

#include "WndBase.h"
#include "WndButton.h"
#include "WndLoadPicture.h"
#include "UICreateFactory.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_SIZE (lua_State* tolua_S)
{
 SIZE* self = (SIZE*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CWndBase (lua_State* tolua_S)
{
 CWndBase* self = (CWndBase*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CWndLoadPicture (lua_State* tolua_S)
{
 CWndLoadPicture* self = (CWndLoadPicture*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_POINT (lua_State* tolua_S)
{
 POINT* self = (POINT*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CWndButton (lua_State* tolua_S)
{
 CWndButton* self = (CWndButton*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_CUICreateFactory (lua_State* tolua_S)
{
 CUICreateFactory* self = (CUICreateFactory*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"SIZE");
 tolua_usertype(tolua_S,"CWndBase");
 tolua_usertype(tolua_S,"POINT");
 tolua_usertype(tolua_S,"CWndLoadPicture");
 tolua_usertype(tolua_S,"CUICreateFactory");
 tolua_usertype(tolua_S,"CWndButton");
}

/* method: new of class  CUICreateFactory */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CUICreateFactory_new00
static int tolua_WndBasePkg_CUICreateFactory_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CUICreateFactory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CUICreateFactory* tolua_ret = (CUICreateFactory*)  Mtolua_new((CUICreateFactory)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CUICreateFactory");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CUICreateFactory */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CUICreateFactory_new00_local
static int tolua_WndBasePkg_CUICreateFactory_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CUICreateFactory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CUICreateFactory* tolua_ret = (CUICreateFactory*)  Mtolua_new((CUICreateFactory)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CUICreateFactory");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_new00
static int tolua_WndBasePkg_CWndBase_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CWndBase* tolua_ret = (CWndBase*)  Mtolua_new((CWndBase)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CWndBase");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_new00_local
static int tolua_WndBasePkg_CWndBase_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CWndBase* tolua_ret = (CWndBase*)  Mtolua_new((CWndBase)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CWndBase");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Create of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_Create00
static int tolua_WndBasePkg_CWndBase_Create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"CWndBase",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
  int cx = ((int)  tolua_tonumber(tolua_S,4,0));
  int cy = ((int)  tolua_tonumber(tolua_S,5,0));
  CWndBase* pParent = ((CWndBase*)  tolua_tousertype(tolua_S,6,0));
  int nID = ((int)  tolua_tonumber(tolua_S,7,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Create'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->Create(x,y,cx,cy,pParent,nID);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsVisible of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_IsVisible00
static int tolua_WndBasePkg_CWndBase_IsVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsVisible'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->IsVisible();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetParent of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_SetParent00
static int tolua_WndBasePkg_CWndBase_SetParent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
  CWndBase* pParent = ((CWndBase*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetParent'", NULL);
#endif
  {
   CWndBase* tolua_ret = (CWndBase*)  self->SetParent(pParent);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CWndBase");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetParent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetParent of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_GetParent00
static int tolua_WndBasePkg_CWndBase_GetParent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetParent'", NULL);
#endif
  {
   CWndBase* tolua_ret = (CWndBase*)  self->GetParent();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CWndBase");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetParent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWindowEnabled of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_IsWindowEnabled00
static int tolua_WndBasePkg_CWndBase_IsWindowEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWindowEnabled'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->IsWindowEnabled();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWindowEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ResizeWindow of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_ResizeWindow00
static int tolua_WndBasePkg_CWndBase_ResizeWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
  int cx = ((int)  tolua_tonumber(tolua_S,2,0));
  int cy = ((int)  tolua_tonumber(tolua_S,3,0));
  bool bRedraw = ((bool)  tolua_toboolean(tolua_S,4,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ResizeWindow'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->ResizeWindow(cx,cy,bRedraw);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ResizeWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MoveWindow of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_MoveWindow00
static int tolua_WndBasePkg_CWndBase_MoveWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
  bool bRedraw = ((bool)  tolua_toboolean(tolua_S,4,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MoveWindow'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->MoveWindow(x,y,bRedraw);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MoveWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShowWindow of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_ShowWindow00
static int tolua_WndBasePkg_CWndBase_ShowWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
  bool bVisible = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShowWindow'", NULL);
#endif
  {
   self->ShowWindow(bVisible);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShowWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFocus of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_SetFocus00
static int tolua_WndBasePkg_CWndBase_SetFocus00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CWndBase",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndBase* pWndFocus = ((CWndBase*)  tolua_tousertype(tolua_S,2,0));
  {
   CWndBase* tolua_ret = (CWndBase*)  CWndBase::SetFocus(pWndFocus);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CWndBase");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFocus'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetClientPos of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_GetClientPos00
static int tolua_WndBasePkg_CWndBase_GetClientPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const CWndBase* self = (const CWndBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetClientPos'", NULL);
#endif
  {
   POINT tolua_ret = (POINT)  self->GetClientPos();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((POINT)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"POINT");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(POINT));
     tolua_pushusertype(tolua_S,tolua_obj,"POINT");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetClientPos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetClientSize of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_GetClientSize00
static int tolua_WndBasePkg_CWndBase_GetClientSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const CWndBase* self = (const CWndBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetClientSize'", NULL);
#endif
  {
   SIZE tolua_ret = (SIZE)  self->GetClientSize();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((SIZE)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"SIZE");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(SIZE));
     tolua_pushusertype(tolua_S,tolua_obj,"SIZE");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetClientSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDlgID of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndBase_GetDlgID00
static int tolua_WndBasePkg_CWndBase_GetDlgID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const CWndBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const CWndBase* self = (const CWndBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDlgID'", NULL);
#endif
  {
   int tolua_ret = (int)  self->GetDlgID();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDlgID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_bDrawBox of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_get_CWndBase_m_bDrawBox
static int tolua_get_CWndBase_m_bDrawBox(lua_State* tolua_S)
{
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_bDrawBox'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->m_bDrawBox);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_bDrawBox of class  CWndBase */
#ifndef TOLUA_DISABLE_tolua_set_CWndBase_m_bDrawBox
static int tolua_set_CWndBase_m_bDrawBox(lua_State* tolua_S)
{
  CWndBase* self = (CWndBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_bDrawBox'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_bDrawBox = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CWndButton */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndButton_new00
static int tolua_WndBasePkg_CWndButton_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CWndButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CWndButton* tolua_ret = (CWndButton*)  Mtolua_new((CWndButton)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CWndButton");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CWndButton */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndButton_new00_local
static int tolua_WndBasePkg_CWndButton_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CWndButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CWndButton* tolua_ret = (CWndButton*)  Mtolua_new((CWndButton)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CWndButton");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Create of class  CWndButton */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndButton_Create00
static int tolua_WndBasePkg_CWndButton_Create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndButton",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isstring(tolua_S,6,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,7,"CWndBase",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,9,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndButton* self = (CWndButton*)  tolua_tousertype(tolua_S,1,0);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
  int cx = ((int)  tolua_tonumber(tolua_S,4,0));
  int cy = ((int)  tolua_tonumber(tolua_S,5,0));
  const char* pPath = ((const char*)  tolua_tostring(tolua_S,6,0));
  CWndBase* pParent = ((CWndBase*)  tolua_tousertype(tolua_S,7,0));
  int nID = ((int)  tolua_tonumber(tolua_S,8,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Create'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->Create(x,y,cx,cy,pPath,pParent,nID);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBtnState of class  CWndButton */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndButton_SetBtnState00
static int tolua_WndBasePkg_CWndButton_SetBtnState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndButton",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndButton* self = (CWndButton*)  tolua_tousertype(tolua_S,1,0);
  int nBtnState = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBtnState'", NULL);
#endif
  {
   self->SetBtnState(nBtnState);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBtnState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDataFile of class  CWndButton */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndButton_SetDataFile00
static int tolua_WndBasePkg_CWndButton_SetDataFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndButton",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndButton* self = (CWndButton*)  tolua_tousertype(tolua_S,1,0);
  const char* pFilePath = ((const char*)  tolua_tostring(tolua_S,2,0));
  int xStart = ((int)  tolua_tonumber(tolua_S,3,0));
  int yStart = ((int)  tolua_tonumber(tolua_S,4,0));
  int nWidth = ((int)  tolua_tonumber(tolua_S,5,0));
  int nHeight = ((int)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDataFile'", NULL);
#endif
  {
   self->SetDataFile(pFilePath,xStart,yStart,nWidth,nHeight);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDataFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CWndLoadPicture */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndLoadPicture_new00
static int tolua_WndBasePkg_CWndLoadPicture_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CWndLoadPicture",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CWndLoadPicture* tolua_ret = (CWndLoadPicture*)  Mtolua_new((CWndLoadPicture)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CWndLoadPicture");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CWndLoadPicture */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndLoadPicture_new00_local
static int tolua_WndBasePkg_CWndLoadPicture_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"CWndLoadPicture",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   CWndLoadPicture* tolua_ret = (CWndLoadPicture*)  Mtolua_new((CWndLoadPicture)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CWndLoadPicture");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Create of class  CWndLoadPicture */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndLoadPicture_Create00
static int tolua_WndBasePkg_CWndLoadPicture_Create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndLoadPicture",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CWndBase",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,7,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,9,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,10,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,11,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,12,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndLoadPicture* self = (CWndLoadPicture*)  tolua_tousertype(tolua_S,1,0);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
  const char* pPath = ((const char*)  tolua_tostring(tolua_S,4,0));
  CWndBase* pParent = ((CWndBase*)  tolua_tousertype(tolua_S,5,0));
  int nID = ((int)  tolua_tonumber(tolua_S,6,0));
  bool bDrawSprite = ((bool)  tolua_toboolean(tolua_S,7,0));
  int ptDrawX = ((int)  tolua_tonumber(tolua_S,8,0));
  int ptDrawY = ((int)  tolua_tonumber(tolua_S,9,0));
  int ptDrawW = ((int)  tolua_tonumber(tolua_S,10,0));
  int ptDrawH = ((int)  tolua_tonumber(tolua_S,11,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Create'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->Create(x,y,pPath,pParent,nID,bDrawSprite,ptDrawX,ptDrawY,ptDrawW,ptDrawH);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ResetRes of class  CWndLoadPicture */
#ifndef TOLUA_DISABLE_tolua_WndBasePkg_CWndLoadPicture_ResetRes00
static int tolua_WndBasePkg_CWndLoadPicture_ResetRes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"CWndLoadPicture",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CWndLoadPicture* self = (CWndLoadPicture*)  tolua_tousertype(tolua_S,1,0);
  const char* pPath = ((const char*)  tolua_tostring(tolua_S,2,0));
  bool bDrawSprite = ((bool)  tolua_toboolean(tolua_S,3,0));
  int ptDrawX = ((int)  tolua_tonumber(tolua_S,4,0));
  int ptDrawY = ((int)  tolua_tonumber(tolua_S,5,0));
  int ptDrawW = ((int)  tolua_tonumber(tolua_S,6,0));
  int ptDrawH = ((int)  tolua_tonumber(tolua_S,7,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ResetRes'", NULL);
#endif
  {
   self->ResetRes(pPath,bDrawSprite,ptDrawX,ptDrawY,ptDrawW,ptDrawH);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ResetRes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: x of class  POINT */
#ifndef TOLUA_DISABLE_tolua_get_POINT_x
static int tolua_get_POINT_x(lua_State* tolua_S)
{
  POINT* self = (POINT*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->x);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: x of class  POINT */
#ifndef TOLUA_DISABLE_tolua_set_POINT_x
static int tolua_set_POINT_x(lua_State* tolua_S)
{
  POINT* self = (POINT*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->x = ((  long)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: y of class  POINT */
#ifndef TOLUA_DISABLE_tolua_get_POINT_y
static int tolua_get_POINT_y(lua_State* tolua_S)
{
  POINT* self = (POINT*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->y);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: y of class  POINT */
#ifndef TOLUA_DISABLE_tolua_set_POINT_y
static int tolua_set_POINT_y(lua_State* tolua_S)
{
  POINT* self = (POINT*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->y = ((  long)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: cx of class  SIZE */
#ifndef TOLUA_DISABLE_tolua_get_SIZE_cx
static int tolua_get_SIZE_cx(lua_State* tolua_S)
{
  SIZE* self = (SIZE*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cx'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->cx);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: cx of class  SIZE */
#ifndef TOLUA_DISABLE_tolua_set_SIZE_cx
static int tolua_set_SIZE_cx(lua_State* tolua_S)
{
  SIZE* self = (SIZE*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cx'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->cx = ((  int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: cy of class  SIZE */
#ifndef TOLUA_DISABLE_tolua_get_SIZE_cy
static int tolua_get_SIZE_cy(lua_State* tolua_S)
{
  SIZE* self = (SIZE*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cy'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->cy);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: cy of class  SIZE */
#ifndef TOLUA_DISABLE_tolua_set_SIZE_cy
static int tolua_set_SIZE_cy(lua_State* tolua_S)
{
  SIZE* self = (SIZE*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cy'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->cy = ((  int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_WndBasePkg_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CUICreateFactory","CUICreateFactory","",tolua_collect_CUICreateFactory);
  #else
  tolua_cclass(tolua_S,"CUICreateFactory","CUICreateFactory","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CUICreateFactory");
   tolua_function(tolua_S,"new",tolua_WndBasePkg_CUICreateFactory_new00);
   tolua_function(tolua_S,"new_local",tolua_WndBasePkg_CUICreateFactory_new00_local);
   tolua_function(tolua_S,".call",tolua_WndBasePkg_CUICreateFactory_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CWndBase","CWndBase","",tolua_collect_CWndBase);
  #else
  tolua_cclass(tolua_S,"CWndBase","CWndBase","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CWndBase");
   tolua_function(tolua_S,"new",tolua_WndBasePkg_CWndBase_new00);
   tolua_function(tolua_S,"new_local",tolua_WndBasePkg_CWndBase_new00_local);
   tolua_function(tolua_S,".call",tolua_WndBasePkg_CWndBase_new00_local);
   tolua_function(tolua_S,"Create",tolua_WndBasePkg_CWndBase_Create00);
   tolua_function(tolua_S,"IsVisible",tolua_WndBasePkg_CWndBase_IsVisible00);
   tolua_function(tolua_S,"SetParent",tolua_WndBasePkg_CWndBase_SetParent00);
   tolua_function(tolua_S,"GetParent",tolua_WndBasePkg_CWndBase_GetParent00);
   tolua_function(tolua_S,"IsWindowEnabled",tolua_WndBasePkg_CWndBase_IsWindowEnabled00);
   tolua_function(tolua_S,"ResizeWindow",tolua_WndBasePkg_CWndBase_ResizeWindow00);
   tolua_function(tolua_S,"MoveWindow",tolua_WndBasePkg_CWndBase_MoveWindow00);
   tolua_function(tolua_S,"ShowWindow",tolua_WndBasePkg_CWndBase_ShowWindow00);
   tolua_function(tolua_S,"SetFocus",tolua_WndBasePkg_CWndBase_SetFocus00);
   tolua_function(tolua_S,"GetClientPos",tolua_WndBasePkg_CWndBase_GetClientPos00);
   tolua_function(tolua_S,"GetClientSize",tolua_WndBasePkg_CWndBase_GetClientSize00);
   tolua_function(tolua_S,"GetDlgID",tolua_WndBasePkg_CWndBase_GetDlgID00);
   tolua_variable(tolua_S,"m_bDrawBox",tolua_get_CWndBase_m_bDrawBox,tolua_set_CWndBase_m_bDrawBox);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CWndButton","CWndButton","CWndBase",tolua_collect_CWndButton);
  #else
  tolua_cclass(tolua_S,"CWndButton","CWndButton","CWndBase",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CWndButton");
   tolua_function(tolua_S,"new",tolua_WndBasePkg_CWndButton_new00);
   tolua_function(tolua_S,"new_local",tolua_WndBasePkg_CWndButton_new00_local);
   tolua_function(tolua_S,".call",tolua_WndBasePkg_CWndButton_new00_local);
   tolua_function(tolua_S,"Create",tolua_WndBasePkg_CWndButton_Create00);
   tolua_function(tolua_S,"SetBtnState",tolua_WndBasePkg_CWndButton_SetBtnState00);
   tolua_function(tolua_S,"SetDataFile",tolua_WndBasePkg_CWndButton_SetDataFile00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"CWndLoadPicture","CWndLoadPicture","CWndBase",tolua_collect_CWndLoadPicture);
  #else
  tolua_cclass(tolua_S,"CWndLoadPicture","CWndLoadPicture","CWndBase",NULL);
  #endif
  tolua_beginmodule(tolua_S,"CWndLoadPicture");
   tolua_function(tolua_S,"new",tolua_WndBasePkg_CWndLoadPicture_new00);
   tolua_function(tolua_S,"new_local",tolua_WndBasePkg_CWndLoadPicture_new00_local);
   tolua_function(tolua_S,".call",tolua_WndBasePkg_CWndLoadPicture_new00_local);
   tolua_function(tolua_S,"Create",tolua_WndBasePkg_CWndLoadPicture_Create00);
   tolua_function(tolua_S,"ResetRes",tolua_WndBasePkg_CWndLoadPicture_ResetRes00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"POINT","POINT","",tolua_collect_POINT);
  #else
  tolua_cclass(tolua_S,"POINT","POINT","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"POINT");
   tolua_variable(tolua_S,"x",tolua_get_POINT_x,tolua_set_POINT_x);
   tolua_variable(tolua_S,"y",tolua_get_POINT_y,tolua_set_POINT_y);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"SIZE","SIZE","",tolua_collect_SIZE);
  #else
  tolua_cclass(tolua_S,"SIZE","SIZE","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"SIZE");
   tolua_variable(tolua_S,"cx",tolua_get_SIZE_cx,tolua_set_SIZE_cx);
   tolua_variable(tolua_S,"cy",tolua_get_SIZE_cy,tolua_set_SIZE_cy);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static const unsigned char B[] = {
    10, 98, 97,115,101,119,110,100, 61,123,125, 10,102,117,110,
     99,116,105,111,110, 32, 98, 97,115,101,119,110,100, 46,116,
    111, 79, 98,106,101, 99,116, 40,101, 44, 99,110, 97,109,101,
     41, 10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46,
     99, 97,115,116, 40,101, 44, 99,110, 97,109,101, 41, 10,101,
    110,100, 45, 45, 45,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 1");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_WndBasePkg (lua_State* tolua_S) {
 return tolua_WndBasePkg_open(tolua_S);
};
#endif

